package patterns;

/**
 * 工厂模式示例：静态工厂、简单工厂、工厂方法、抽象工厂
 */
public class LearnFactory {
    public static void main(String[] args) {
        // 1. 静态工厂
        Product staticProduct = StaticFactory.createProduct();
        staticProduct.show();

        // 2. 简单工厂
        Product simpleA = SimpleFactory.createProduct("A");
        Product simpleB = SimpleFactory.createProduct("B");
        simpleA.show();
        simpleB.show();

        // 3. 工厂方法
        Factory factoryA = new FactoryA();
        Factory factoryB = new FactoryB();
        Product methodA = factoryA.createProduct();
        Product methodB = factoryB.createProduct();
        methodA.show();
        methodB.show();

        // 4. 抽象工厂：和工厂方法的区别就是可以有多个一系列的产品
        AbstractFactory af1 = new ConcreteFactory1();
        AbstractFactory af2 = new ConcreteFactory2();
        Product product1 = af1.createProduct();
        Gift gift1 = af1.createGift();
        Product product2 = af2.createProduct();
        Gift gift2 = af2.createGift();
        product1.show();
        gift1.give();
        product2.show();
        gift2.give();
    }
}

// 产品接口
interface Product {
    void show();
}

// 产品实现A
class ProductA implements Product {
    public void show() {
        System.out.println("产品A");
    }
}
// 产品实现B
class ProductB implements Product {
    public void show() {
        System.out.println("产品B");
    }
}

// 1. 静态工厂模式：使用一个静态方法来返回对象实例。
class StaticFactory {
    public static Product createProduct() {
        return new ProductA();
    }
}

// 2. 简单工厂模式：通过一个工厂类根据传入参数决定实例化哪个具体类（多个子类中的一个）。
class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type))
            return new ProductA();
        else if ("B".equals(type))
            return new ProductB();
        else
            throw new IllegalArgumentException("未知产品类型: " + type);
    }
}

// 3. 工厂方法模式：将对象的创建交给子类，每个子类实现自己的工厂方法，生产对应的产品。
interface Factory {
    Product createProduct();
}
class FactoryA implements Factory {
    public Product createProduct() {
        return new ProductA();
    }
}
class FactoryB implements Factory {
    public Product createProduct() {
        return new ProductB();
    }
}

// 4. 抽象工厂模式：提供一个接口，用于创建一组相关或依赖的对象，而无需指定它们的具体类。
interface Gift {
    void give();
}
class GiftA implements Gift {
    public void give() {
        System.out.println("赠品A");
    }
}
class GiftB implements Gift {
    public void give() {
        System.out.println("赠品B");
    }
}
interface AbstractFactory {
    Product createProduct();
    Gift createGift();
}
class ConcreteFactory1 implements AbstractFactory {
    public Product createProduct() {
        return new ProductA();
    }
    public Gift createGift() {
        return new GiftA();
    }
}
class ConcreteFactory2 implements AbstractFactory {
    public Product createProduct() {
        return new ProductB();
    }
    public Gift createGift() {
        return new GiftB();
    }
} 